package com.example.service.impl;

import com.example.mapper.controlPlanMapp;
import com.example.pojo.ThreeList;
import com.example.pojo.controlPlanPojo;
import com.example.service.controlPlanService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * ClassName:controlPlanlmpl
 * Description:
 *
 * @Author 赵永峰
 * @Create 2024/5/23 16:12
 * @Version 1.0
 */
@Service//注解：表示把这个注入到了ben中。
@Slf4j//可以输出注解
public  class controlPlanImpl implements controlPlanService {
    @Autowired
    private controlPlanMapp controlPlanMapp;
    //页面加载的时候，刷新页面的导航栏数据

    public List<ThreeList> controlPlanTreeList(){
        //新建一个list，作为返回值，存放目录的信息；
        List<ThreeList>[] lists = new List[3];
        //查询出导航数据所有数据
        List<ThreeList> TreeAll = new ArrayList<>();

        List<String> TreeOne = controlPlanMapp.OneOneStr("workshopEnglish");
        for (int i = 0; i < TreeOne.size(); i++) {
            ThreeList rootOne = new ThreeList(TreeOne.get(i));
            //筛选出二级目录的元素。
            List<String> TreeTow = controlPlanMapp.findDistinctBValuesByA("Drawing", "workshopEnglish", TreeOne.get(i));
            for (int j = 0; j <TreeTow.size() ; j++) {
                //新建一个导航数据结构的列表，用作存储二级目录的数据；
                ThreeList rootTow = new ThreeList(TreeTow.get(j));
                //筛选出三级目录的元素
                List<String> TreeThree =controlPlanMapp.findDistinctBValuesByAandB(
                        "op",
                        "workshopEnglish",
                        TreeOne.get(i),
                        "Drawing",
                        TreeTow.get(j)
                );
                //把筛选出来的三级目录增加到数组中。
                for (int k = 0; k < TreeThree.size(); k++) {
                    //新建一个导航栏结构的列表，存储三级目录的数据信息
                    ThreeList rootThree = new ThreeList();
                    //设置三级数据类别的label的值；
                    rootThree.setLabel("OP"+TreeThree.get(k));
                    //把三级目录添加到整体的目录中，需要添加到二级的Children中
                    rootTow.getChildren().add(rootThree);
                }
                //对数据进行排序
                for (int k = 1; k < rootTow.getChildren().size(); k++) {
                    // 取出需要排序的数据, 先取当前项，一会和前面的对比
                    String subStr2 = rootTow.getChildren().get(k).getLabel();
                    int endIndex2 = subStr2.indexOf("-"); // 查找'-'或字符串末尾
                    if (endIndex2 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                        endIndex2 = subStr2.length();
                    }
                    int subNum2 = Integer.parseInt(subStr2.substring(2, endIndex2)); // 假设索引从2开始取数字

                    // 循环和前面的对比
                    for (int l = k; l > 0; l--) { // 注意这里l > 0
                        // 取出前面的项
                        String subStr1 = rootTow.getChildren().get(l - 1).getLabel();
                        int endIndex1 = subStr1.indexOf("-"); // 查找'-'或字符串末尾
                        if (endIndex1 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                            endIndex1 = subStr1.length();
                        }
                        int subNum1 = Integer.parseInt(subStr1.substring(2, endIndex1)); // 假设索引从2开始取数字

                        // 对比两个数
                        if (subNum1 > subNum2) {
                            // 需要交换位置
                            ThreeList temp = rootTow.getChildren().get(l - 1); // 获取前面的项
                            rootTow.getChildren().set(l - 1, rootTow.getChildren().get(l)); // 将当前项放到前面项的位置
                            rootTow.getChildren().set(l, temp); // 将前面项放到当前项的位置，完成交换
                        } else {
                            // 如果subNum1不大于subNum2，则无需继续向前比较，因为前面的项已经是有序的
                            break;
                        }
                    }
                }
                //把二级目录添加到整体目录中，需要添加到一级的Children中
                rootOne.getChildren().add(rootTow);
            }
            TreeAll.add(rootOne);
        }
        //把英文的列表记录下来
        lists[0]=TreeAll;
        //查询出中文的导航数据
        TreeOne = controlPlanMapp.OneOneStr("workshop");
        for (int i = 0; i < TreeOne.size(); i++) {
            ThreeList rootOne = new ThreeList(TreeOne.get(i));
            //筛选出二级目录的元素。
            List<String> TreeTow = controlPlanMapp.findDistinctBValuesByA("Drawing", "workshop", TreeOne.get(i));
            for (int j = 0; j <TreeTow.size() ; j++) {
                //新建一个导航数据结构的列表，用作存储二级目录的数据；
                ThreeList rootTow = new ThreeList(TreeTow.get(j));
                //筛选出三级目录的元素
                List<String> TreeThree =controlPlanMapp.findDistinctBValuesByAandB(
                        "op",
                        "workshop",
                        TreeOne.get(i),
                        "Drawing",
                        TreeTow.get(j)
                );
                //把筛选出来的三级目录增加到数组中。
                for (int k = 0; k < TreeThree.size(); k++) {
                    //新建一个导航栏结构的列表，存储三级目录的数据信息
                    ThreeList rootThree = new ThreeList();
                    //设置三级数据类别的label的值；
                    rootThree.setLabel("OP"+TreeThree.get(k));
                    //把三级目录添加到整体的目录中，需要添加到二级的Children中
                    rootTow.getChildren().add(rootThree);
                }
                //对数据进行排序
                for (int k = 1; k < rootTow.getChildren().size(); k++) {
                    // 取出需要排序的数据, 先取当前项，一会和前面的对比
                    String subStr2 = rootTow.getChildren().get(k).getLabel();
                    int endIndex2 = subStr2.indexOf("-"); // 查找'-'或字符串末尾
                    if (endIndex2 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                        endIndex2 = subStr2.length();
                    }
                    int subNum2 = Integer.parseInt(subStr2.substring(2, endIndex2)); // 假设索引从2开始取数字

                    // 循环和前面的对比
                    for (int l = k; l > 0; l--) { // 注意这里l > 0
                        // 取出前面的项
                        String subStr1 = rootTow.getChildren().get(l - 1).getLabel();
                        int endIndex1 = subStr1.indexOf("-"); // 查找'-'或字符串末尾
                        if (endIndex1 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                            endIndex1 = subStr1.length();
                        }
                        int subNum1 = Integer.parseInt(subStr1.substring(2, endIndex1)); // 假设索引从2开始取数字

                        // 对比两个数
                        if (subNum1 > subNum2) {
                            // 需要交换位置
                            ThreeList temp = rootTow.getChildren().get(l - 1); // 获取前面的项
                            rootTow.getChildren().set(l - 1, rootTow.getChildren().get(l)); // 将当前项放到前面项的位置
                            rootTow.getChildren().set(l, temp); // 将前面项放到当前项的位置，完成交换
                        } else {
                            // 如果subNum1不大于subNum2，则无需继续向前比较，因为前面的项已经是有序的
                            break;
                        }
                    }
                }
                //把二级目录添加到整体目录中，需要添加到一级的Children中
                rootOne.getChildren().add(rootTow);
            }
            TreeAll.add(rootOne);
        }
        //把中文的列表记录下来
        lists[1]=TreeAll;
//        //查询出俄语的导航数据
        TreeOne = controlPlanMapp.OneOneStr("workshopRussian");
        for (int i = 0; i < TreeOne.size(); i++) {
            ThreeList rootOne = new ThreeList(TreeOne.get(i));
            //筛选出二级目录的元素。
            List<String> TreeTow = controlPlanMapp.findDistinctBValuesByA("Drawing", "workshopRussian", TreeOne.get(i));
            for (int j = 0; j <TreeTow.size() ; j++) {
                //新建一个导航数据结构的列表，用作存储二级目录的数据；
                ThreeList rootTow = new ThreeList(TreeTow.get(j));
                //筛选出三级目录的元素
                List<String> TreeThree =controlPlanMapp.findDistinctBValuesByAandB(
                        "op",
                        "workshopRussian",
                        TreeOne.get(i),
                        "Drawing",
                        TreeTow.get(j)
                );
                //把筛选出来的三级目录增加到数组中。
                for (int k = 0; k < TreeThree.size(); k++) {
                    //新建一个导航栏结构的列表，存储三级目录的数据信息
                    ThreeList rootThree = new ThreeList();
                    //设置三级数据类别的label的值；
                    rootThree.setLabel("OP"+TreeThree.get(k));
                    //把三级目录添加到整体的目录中，需要添加到二级的Children中
                    rootTow.getChildren().add(rootThree);
                }
                //对数据进行排序
                for (int k = 1; k < rootTow.getChildren().size(); k++) {
                    // 取出需要排序的数据, 先取当前项，一会和前面的对比
                    String subStr2 = rootTow.getChildren().get(k).getLabel();
                    int endIndex2 = subStr2.indexOf("-"); // 查找'-'或字符串末尾
                    if (endIndex2 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                        endIndex2 = subStr2.length();
                    }
                    int subNum2 = Integer.parseInt(subStr2.substring(2, endIndex2)); // 假设索引从2开始取数字

                    // 循环和前面的对比
                    for (int l = k; l > 0; l--) { // 注意这里l > 0
                        // 取出前面的项
                        String subStr1 = rootTow.getChildren().get(l - 1).getLabel();
                        int endIndex1 = subStr1.indexOf("-"); // 查找'-'或字符串末尾
                        if (endIndex1 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                            endIndex1 = subStr1.length();
                        }
                        int subNum1 = Integer.parseInt(subStr1.substring(2, endIndex1)); // 假设索引从2开始取数字

                        // 对比两个数
                        if (subNum1 > subNum2) {
                            // 需要交换位置
                            ThreeList temp = rootTow.getChildren().get(l - 1); // 获取前面的项
                            rootTow.getChildren().set(l - 1, rootTow.getChildren().get(l)); // 将当前项放到前面项的位置
                            rootTow.getChildren().set(l, temp); // 将前面项放到当前项的位置，完成交换
                        } else {
                            // 如果subNum1不大于subNum2，则无需继续向前比较，因为前面的项已经是有序的
                            break;
                        }
                    }
                }
                //把二级目录添加到整体目录中，需要添加到一级的Children中
                rootOne.getChildren().add(rootTow);
            }
            TreeAll.add(rootOne);
        }
//        //把俄文的列表记录下来
        lists[2]=TreeAll;
        System.out.println(TreeAll);
        return TreeAll;
    }


    //新的控制计划数据库用到的函数
    //根据三个字段查询所有数据,用模糊查询(数据都是字符串类型）
    public List<controlPlanPojo> inquiryControlPlanByOp(Map<String, Object> parameters){
        String firstFieldName=(String) parameters.get("firstFieldName");
        String firstFieldVal=(String) parameters.get("firstFieldVal");
        String secondFieldName=(String) parameters.get("secondFieldName");
        String secondFieldVal=(String) parameters.get("secondFieldVal");
        String thirdFieldName=(String) parameters.get("thirdFieldName");
        String thirdFieldVal=(String) parameters.get("thirdFieldVal");
        List<controlPlanPojo> controlPlanPojoList=controlPlanMapp.strFieldThree(firstFieldName,firstFieldVal,secondFieldName,secondFieldVal,thirdFieldName,thirdFieldVal);
        for (int i = 0; i < controlPlanPojoList.size(); i++) {
            System.out.println(controlPlanPojoList.get(i));
        }

        return controlPlanPojoList;
    }
    //查询出工序作业指导书中，与控制计划关联的项目
    public List<controlPlanPojo> inquiryControlPlanAssociationByOperateGuideBook(String param){
        System.out.println(param);
        String[] fieldId = param.split("\\|\\*\\|");
        List<controlPlanPojo> controlPlanPojoList=new ArrayList<>();
        for (int i = 0; i < fieldId.length; i++) {
            try {
                int number = Integer.parseInt(fieldId[i]);
                System.out.println(number);
                controlPlanPojo controlPlanPojo=controlPlanMapp.inquiryById(number);
                if (controlPlanPojo !=null){
                    controlPlanPojoList.add(controlPlanPojo);
                }
            } catch (NumberFormatException e) {
                e.printStackTrace();
            }
        }
        return controlPlanPojoList;
    }
    //插入一行
    public void controlPlanVoidInsert(controlPlanPojo controlPlan){
        //组合创建时间
        controlPlan.setEstablishTime(LocalDateTime.now());
        controlPlanMapp.insertOne(controlPlan);
    }
    //根据ID，修改一行的值
    public void controlPlanVoidPut(controlPlanPojo controlPlanPojo){
            //组合修改该日期
            controlPlanPojo.setUpdateTime(LocalDateTime.now());
            controlPlanMapp.putById(controlPlanPojo);
    }
    //根据id，查询数据
    public List<controlPlanPojo> controlPlanList(controlPlanPojo controlPlanPojo){
        List<controlPlanPojo> controlPlanPojoList=controlPlanMapp.controlPlanList(controlPlanPojo);
        return controlPlanPojoList;
    }
    //根据ID修改“控制计划”标记为的值，传递ID、修改值
    public void putTestingById(Integer controlTesting){
        //转换出控制计划的ID。
        controlPlanMapp.putTestingById(String.valueOf(controlTesting),controlTesting);
    }
    //根据id，查询出一条控制计划的内容
    public controlPlanPojo controlPlanById(Integer id){
        controlPlanPojo controlPlanPojo=controlPlanMapp.controlPlanById(id);
        return controlPlanPojo;
    }

}
